home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !tex / TeXsource / web2ctex / ctex / c / tex3 < prev    next >
Encoding:
Text File  |  1988-05-19  |  45.6 KB  |  2,165 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. scanint () {
  5.     /* 30 */ scanint_regmem 
  6.   boolean negative  ; 
  7.   integer m  ; 
  8.   smallnumber d  ; 
  9.   boolean vacuous  ; 
  10.   boolean OKsofar  ; 
  11.   radix = 0 ; 
  12.   OKsofar = true ; 
  13.   negative = false ; 
  14.   do {
  15.       do { getxtoken () ; 
  16.     } while ( ! ( curcmd != 10 ) ) ; 
  17.     if ( curtok == 3117 ) 
  18.     {
  19.       negative = ! negative ; 
  20.       curtok = 3115 ; 
  21.     } 
  22.   } while ( ! ( curtok != 3115 ) ) ; 
  23.   if ( curtok == 3168 ) 
  24.   {
  25.     gettoken () ; 
  26.     if ( curtok < 4096 ) 
  27.     {
  28.       curval = curchr ; 
  29.       if ( curcmd <= 2 ) 
  30.       if ( curcmd == 2 ) 
  31.       incr ( alignstate ) ; 
  32.       else decr ( alignstate ) ; 
  33.     } 
  34.     else if ( curtok < 4225 ) 
  35.     curval = curtok - 4097 ; 
  36.     else curval = curtok - 4225 ; 
  37.     if ( curval > 127 ) 
  38.     {
  39.       {
  40.     if ( interaction == 3 ) 
  41.     wakeupterminal () ; 
  42.     printnl ( 133 ) ; 
  43.     print ( 555 ) ; 
  44.       } 
  45.       {
  46.     helpptr = 2 ; 
  47.     helpline [ 1 ] = 556 ; 
  48.     helpline [ 0 ] = 557 ; 
  49.       } 
  50.       curval = 48 ; 
  51.       backerror () ; 
  52.     } 
  53.     else {
  54.     
  55.       getxtoken () ; 
  56.       if ( curcmd != 10 ) 
  57.       backinput () ; 
  58.     } 
  59.   } 
  60.   else if ( ( curcmd >= 67 ) && ( curcmd <= 88 ) ) 
  61.   scansomethinginterna ( 0 , false ) ; 
  62.   else {
  63.       
  64.     radix = 10 ; 
  65.     m = 214748364L ; 
  66.     if ( curtok == 3111 ) 
  67.     {
  68.       radix = 8 ; 
  69.       m = 268435456L ; 
  70.       getxtoken () ; 
  71.     } 
  72.     else if ( curtok == 3106 ) 
  73.     {
  74.       radix = 16 ; 
  75.       m = 134217728L ; 
  76.       getxtoken () ; 
  77.     } 
  78.     vacuous = true ; 
  79.     curval = 0 ; 
  80.     while ( true ) {
  81.     
  82.       if ( ( curtok < 3120 + radix ) && ( curtok >= 3120 ) && ( curtok <= 3129 
  83.       ) ) 
  84.       d = curtok - 3120 ; 
  85.       else if ( radix == 16 ) 
  86.       if ( ( curtok <= 2886 ) && ( curtok >= 2881 ) ) 
  87.       d = curtok - 2871 ; 
  88.       else if ( ( curtok <= 3142 ) && ( curtok >= 3137 ) ) 
  89.       d = curtok - 3127 ; 
  90.       else goto lab30 ; 
  91.       else goto lab30 ; 
  92.       vacuous = false ; 
  93.       if ( ( curval >= m ) && ( ( curval > m ) || ( d > 7 ) || ( radix != 10 ) 
  94.       ) ) 
  95.       {
  96.     if ( OKsofar ) 
  97.     {
  98.       {
  99.         if ( interaction == 3 ) 
  100.         wakeupterminal () ; 
  101.         printnl ( 133 ) ; 
  102.         print ( 558 ) ; 
  103.       } 
  104.       {
  105.         helpptr = 2 ; 
  106.         helpline [ 1 ] = 559 ; 
  107.         helpline [ 0 ] = 560 ; 
  108.       } 
  109.       error () ; 
  110.       curval = 2147483647L ; 
  111.       OKsofar = false ; 
  112.     } 
  113.       } 
  114.       else curval = curval * radix + d ; 
  115.       getxtoken () ; 
  116.     } 
  117.     lab30: ; 
  118.     if ( vacuous ) 
  119.     {
  120.       {
  121.     if ( interaction == 3 ) 
  122.     wakeupterminal () ; 
  123.     printnl ( 133 ) ; 
  124.     print ( 522 ) ; 
  125.       } 
  126.       {
  127.     helpptr = 3 ; 
  128.     helpline [ 2 ] = 523 ; 
  129.     helpline [ 1 ] = 524 ; 
  130.     helpline [ 0 ] = 525 ; 
  131.       } 
  132.       backerror () ; 
  133.     } 
  134.     else if ( curcmd != 10 ) 
  135.     backinput () ; 
  136.   } 
  137.   if ( negative ) 
  138.   curval = - (integer) curval ; 
  139. } 
  140. zscandimen ( mu , inf , shortcut ) 
  141. boolean mu , inf , shortcut ; 
  142. {/* 30 31 32 40 45 88 89 */ scandimen_regmem 
  143.   boolean negative  ; 
  144.   integer f  ; 
  145.   integer num, denom  ; 
  146.   smallnumber k  ; 
  147.   scaled v  ; 
  148.   integer savecurval  ; 
  149.   f = 0 ; 
  150.   aritherror = false ; 
  151.   curorder = 0 ; 
  152.   negative = false ; 
  153.   if ( ! shortcut ) 
  154.   {
  155.     negative = false ; 
  156.     do {
  157.     do { getxtoken () ; 
  158.       } while ( ! ( curcmd != 10 ) ) ; 
  159.       if ( curtok == 3117 ) 
  160.       {
  161.     negative = ! negative ; 
  162.     curtok = 3115 ; 
  163.       } 
  164.     } while ( ! ( curtok != 3115 ) ) ; 
  165.     if ( ( curcmd >= 67 ) && ( curcmd <= 88 ) ) 
  166.     if ( mu ) 
  167.     {
  168.       scansomethinginterna ( 3 , false ) ; 
  169.       if ( curvallevel >= 2 ) 
  170.       {
  171.     v = mem [ curval + 1 ] .cint ; 
  172.     deleteglueref ( curval ) ; 
  173.     curval = v ; 
  174.       } 
  175.       if ( curvallevel == 3 ) 
  176.       goto lab89 ; 
  177.       if ( curvallevel != 0 ) 
  178.       muerror () ; 
  179.     } 
  180.     else {
  181.     
  182.       scansomethinginterna ( 1 , false ) ; 
  183.       if ( curvallevel == 1 ) 
  184.       goto lab89 ; 
  185.     } 
  186.     else {
  187.     
  188.       backinput () ; 
  189.       if ( curtok == 3116 ) 
  190.       curtok = 3118 ; 
  191.       if ( curtok != 3118 ) 
  192.       scanint () ; 
  193.       else {
  194.       
  195.     radix = 10 ; 
  196.     curval = 0 ; 
  197.       } 
  198.       if ( curtok == 3116 ) 
  199.       curtok = 3118 ; 
  200.       if ( ( radix == 10 ) && ( curtok == 3118 ) ) 
  201.       {
  202.     k = 0 ; 
  203.     gettoken () ; 
  204.     while ( true ) {
  205.         
  206.       getxtoken () ; 
  207.       if ( ( curtok > 3129 ) || ( curtok < 3120 ) ) 
  208.       goto lab31 ; 
  209.       if ( k < 17 ) 
  210.       {
  211.         dig [ k ] = curtok - 3120 ; 
  212.         incr ( k ) ; 
  213.       } 
  214.     } 
  215.     lab31: f = rounddecimals ( k ) ; 
  216.     if ( curcmd != 10 ) 
  217.     backinput () ; 
  218.       } 
  219.     } 
  220.   } 
  221.   if ( curval < 0 ) 
  222.   {
  223.     negative = ! negative ; 
  224.     curval = - (integer) curval ; 
  225.   } 
  226.   if ( inf ) 
  227.   if ( scankeyword ( 180 ) ) 
  228.   {
  229.     curorder = 1 ; 
  230.     while ( scankeyword ( 108 ) ) {
  231.     
  232.       if ( curorder == 3 ) 
  233.       {
  234.     {
  235.       if ( interaction == 3 ) 
  236.       wakeupterminal () ; 
  237.       printnl ( 133 ) ; 
  238.       print ( 562 ) ; 
  239.     } 
  240.     print ( 563 ) ; 
  241.     {
  242.       helpptr = 1 ; 
  243.       helpline [ 0 ] = 564 ; 
  244.     } 
  245.     error () ; 
  246.       } 
  247.       else incr ( curorder ) ; 
  248.     } 
  249.     goto lab88 ; 
  250.   } 
  251.   savecurval = curval ; 
  252.   do {
  253.       getxtoken () ; 
  254.   } while ( ! ( curcmd != 10 ) ) ; 
  255.   if ( ( curcmd < 67 ) || ( curcmd > 88 ) ) 
  256.   backinput () ; 
  257.   else {
  258.       
  259.     if ( mu ) 
  260.     {
  261.       scansomethinginterna ( 3 , false ) ; 
  262.       if ( curvallevel >= 2 ) 
  263.       {
  264.     v = mem [ curval + 1 ] .cint ; 
  265.     deleteglueref ( curval ) ; 
  266.     curval = v ; 
  267.       } 
  268.       if ( curvallevel != 3 ) 
  269.       muerror () ; 
  270.     } 
  271.     else scansomethinginterna ( 1 , false ) ; 
  272.     v = curval ; 
  273.     goto lab40 ; 
  274.   } 
  275.   if ( mu ) 
  276.   goto lab45 ; 
  277.   if ( scankeyword ( 565 ) ) 
  278.   v = ( fontinfo [ 6 + parambase [ eqtb [ 4578 ] .hh .v.RH ] ] .cint ) ; 
  279.   else if ( scankeyword ( 566 ) ) 
  280.   v = ( fontinfo [ 5 + parambase [ eqtb [ 4578 ] .hh .v.RH ] ] .cint ) ; 
  281.   else goto lab45 ; 
  282.   {
  283.     getxtoken () ; 
  284.     if ( curcmd != 10 ) 
  285.     backinput () ; 
  286.   } 
  287.   lab40: curval = nxplusy ( savecurval , v , xnoverd ( v , f , 65536L ) ) ; 
  288.   goto lab89 ; 
  289.   lab45: ; 
  290.   if ( mu ) 
  291.   if ( scankeyword ( 205 ) ) 
  292.   goto lab88 ; 
  293.   else {
  294.       
  295.     {
  296.       if ( interaction == 3 ) 
  297.       wakeupterminal () ; 
  298.       printnl ( 133 ) ; 
  299.       print ( 562 ) ; 
  300.     } 
  301.     print ( 567 ) ; 
  302.     {
  303.       helpptr = 4 ; 
  304.       helpline [ 3 ] = 568 ; 
  305.       helpline [ 2 ] = 569 ; 
  306.       helpline [ 1 ] = 570 ; 
  307.       helpline [ 0 ] = 571 ; 
  308.     } 
  309.     error () ; 
  310.     goto lab88 ; 
  311.   } 
  312.   if ( scankeyword ( 561 ) ) 
  313.   {
  314.     preparemag () ; 
  315.     if ( eqtb [ 5284 ] .cint != 1000 ) 
  316.     {
  317.       curval = xnoverd ( curval , 1000 , eqtb [ 5284 ] .cint ) ; 
  318.       f = ( 1000 * f + 65536L * remainder ) / eqtb [ 5284 ] .cint ; 
  319.       curval = curval + ( f / 65536L ) ; 
  320.       f = f % 65536L ; 
  321.     } 
  322.   } 
  323.   if ( scankeyword ( 262 ) ) 
  324.   goto lab88 ; 
  325.   if ( scankeyword ( 572 ) ) 
  326.   {
  327.     num = 7227 ; 
  328.     denom = 100 ; 
  329.   } 
  330.   else if ( scankeyword ( 573 ) ) 
  331.   {
  332.     num = 12 ; 
  333.     denom = 1 ; 
  334.   } 
  335.   else if ( scankeyword ( 574 ) ) 
  336.   {
  337.     num = 7227 ; 
  338.     denom = 254 ; 
  339.   } 
  340.   else if ( scankeyword ( 575 ) ) 
  341.   {
  342.     num = 7227 ; 
  343.     denom = 2540 ; 
  344.   } 
  345.   else if ( scankeyword ( 576 ) ) 
  346.   {
  347.     num = 7227 ; 
  348.     denom = 7200 ; 
  349.   } 
  350.   else if ( scankeyword ( 577 ) ) 
  351.   {
  352.     num = 1238 ; 
  353.     denom = 1157 ; 
  354.   } 
  355.   else if ( scankeyword ( 578 ) ) 
  356.   {
  357.     num = 14856 ; 
  358.     denom = 1157 ; 
  359.   } 
  360.   else if ( scankeyword ( 579 ) ) 
  361.   goto lab30 ; 
  362.   else {
  363.       
  364.     {
  365.       if ( interaction == 3 ) 
  366.       wakeupterminal () ; 
  367.       printnl ( 133 ) ; 
  368.       print ( 562 ) ; 
  369.     } 
  370.     print ( 580 ) ; 
  371.     {
  372.       helpptr = 6 ; 
  373.       helpline [ 5 ] = 581 ; 
  374.       helpline [ 4 ] = 582 ; 
  375.       helpline [ 3 ] = 583 ; 
  376.       helpline [ 2 ] = 569 ; 
  377.       helpline [ 1 ] = 570 ; 
  378.       helpline [ 0 ] = 571 ; 
  379.     } 
  380.     error () ; 
  381.     goto lab32 ; 
  382.   } 
  383.   curval = xnoverd ( curval , num , denom ) ; 
  384.   f = ( num * f + 65536L * remainder ) / denom ; 
  385.   curval = curval + ( f / 65536L ) ; 
  386.   f = f % 65536L ; 
  387.   lab32: ; 
  388.   lab88: if ( curval >= 16384 ) 
  389.   aritherror = true ; 
  390.   else curval = curval * 65536L + f ; 
  391.   lab30: ; 
  392.   {
  393.     getxtoken () ; 
  394.     if ( curcmd != 10 ) 
  395.     backinput () ; 
  396.   } 
  397.   lab89: if ( aritherror || ( abs ( curval ) >= 1073741824L ) ) 
  398.   {
  399.     {
  400.       if ( interaction == 3 ) 
  401.       wakeupterminal () ; 
  402.       printnl ( 133 ) ; 
  403.       print ( 584 ) ; 
  404.     } 
  405.     {
  406.       helpptr = 2 ; 
  407.       helpline [ 1 ] = 585 ; 
  408.       helpline [ 0 ] = 586 ; 
  409.     } 
  410.     error () ; 
  411.     curval = 1073741823L ; 
  412.     aritherror = false ; 
  413.   } 
  414.   if ( negative ) 
  415.   curval = - (integer) curval ; 
  416. } 
  417. zscanglue ( level ) 
  418. smallnumber level ; 
  419. {/* 10 */ scanglue_regmem 
  420.   boolean negative  ; 
  421.   halfword q  ; 
  422.   boolean mu  ; 
  423.   mu = ( level == 3 ) ; 
  424.   negative = false ; 
  425.   do {
  426.       do { getxtoken () ; 
  427.     } while ( ! ( curcmd != 10 ) ) ; 
  428.     if ( curtok == 3117 ) 
  429.     {
  430.       negative = ! negative ; 
  431.       curtok = 3115 ; 
  432.     } 
  433.   } while ( ! ( curtok != 3115 ) ) ; 
  434.   if ( ( curcmd >= 67 ) && ( curcmd <= 88 ) ) 
  435.   {
  436.     scansomethinginterna ( level , negative ) ; 
  437.     if ( curvallevel >= 2 ) 
  438.     {
  439.       if ( curvallevel != level ) 
  440.       muerror () ; 
  441.       return ; 
  442.     } 
  443.     if ( curvallevel == 0 ) 
  444.     scandimen ( mu , false , true ) ; 
  445.     else if ( level == 3 ) 
  446.     muerror () ; 
  447.   } 
  448.   else {
  449.       
  450.     backinput () ; 
  451.     scandimen ( mu , false , false ) ; 
  452.     if ( negative ) 
  453.     curval = - (integer) curval ; 
  454.   } 
  455.   q = newspec ( 0 ) ; 
  456.   mem [ q + 1 ] .cint = curval ; 
  457.   if ( scankeyword ( 587 ) ) 
  458.   {
  459.     scandimen ( mu , true , false ) ; 
  460.     mem [ q + 2 ] .cint = curval ; 
  461.     mem [ q ] .hh.b0 = curorder ; 
  462.   } 
  463.   if ( scankeyword ( 588 ) ) 
  464.   {
  465.     scandimen ( mu , true , false ) ; 
  466.     mem [ q + 3 ] .cint = curval ; 
  467.     mem [ q ] .hh.b1 = curorder ; 
  468.   } 
  469.   curval = q ; 
  470. } 
  471. halfword scanrulespec () {
  472.     /* 21 */ register halfword Result; 
  473.   scanrulespec_regmem 
  474.   halfword q  ; 
  475.   q = newrule () ; 
  476.   if ( curcmd == 35 ) 
  477.   mem [ q + 1 ] .cint = 26214 ; 
  478.   else {
  479.       
  480.     mem [ q + 3 ] .cint = 26214 ; 
  481.     mem [ q + 2 ] .cint = 0 ; 
  482.   } 
  483.   lab21: if ( scankeyword ( 589 ) ) 
  484.   {
  485.     scandimen ( false , false , false ) ; 
  486.     mem [ q + 1 ] .cint = curval ; 
  487.     goto lab21 ; 
  488.   } 
  489.   if ( scankeyword ( 590 ) ) 
  490.   {
  491.     scandimen ( false , false , false ) ; 
  492.     mem [ q + 3 ] .cint = curval ; 
  493.     goto lab21 ; 
  494.   } 
  495.   if ( scankeyword ( 591 ) ) 
  496.   {
  497.     scandimen ( false , false , false ) ; 
  498.     mem [ q + 2 ] .cint = curval ; 
  499.     goto lab21 ; 
  500.   } 
  501.   Result = q ; 
  502.   return(Result) ; 
  503. } 
  504. halfword strtoks () {
  505.     register halfword Result; strtoks_regmem 
  506.   halfword p  ; 
  507.   halfword q  ; 
  508.   halfword t  ; 
  509.   poolpointer k  ; 
  510.   {
  511.     if ( poolptr + 1 > poolsize ) 
  512.     overflow ( 128 , poolsize - initpoolptr ) ; 
  513.   } 
  514.   p = memtop - 3 ; 
  515.   mem [ p ] .hh .v.RH = 0 ; 
  516.   k = strstart [ strptr ] ; 
  517.   while ( k < poolptr ) {
  518.       
  519.     t = strpool [ k ] ; 
  520.     if ( t == 32 ) 
  521.     t = 2592 ; 
  522.     else t = 3072 + t ; 
  523.     {
  524.       {
  525.     q = avail ; 
  526.     if ( q == 0 ) 
  527.     q = getavail () ; 
  528.     else {
  529.         
  530.       avail = mem [ q ] .hh .v.RH ; 
  531.       mem [ q ] .hh .v.RH = 0 ; 
  532.     ;
  533. #ifdef STAT
  534.       incr ( dynused ) ; 
  535. #endif /* STAT */
  536.     } 
  537.       } 
  538.       mem [ p ] .hh .v.RH = q ; 
  539.       mem [ q ] .hh .v.LH = t ; 
  540.       p = q ; 
  541.     } 
  542.     incr ( k ) ; 
  543.   } 
  544.   poolptr = strstart [ strptr ] ; 
  545.   Result = p ; 
  546.   return(Result) ; 
  547. } 
  548. halfword thetoks () {
  549.     register halfword Result; thetoks_regmem 
  550.   schar oldsetting  ; 
  551.   halfword p, q, r  ; 
  552.   getxtoken () ; 
  553.   scansomethinginterna ( 5 , false ) ; 
  554.   if ( curvallevel >= 4 ) 
  555.   {
  556.     p = memtop - 3 ; 
  557.     mem [ p ] .hh .v.RH = 0 ; 
  558.     if ( curvallevel == 4 ) 
  559.     {
  560.       q = getavail () ; 
  561.       mem [ p ] .hh .v.RH = q ; 
  562.       mem [ q ] .hh .v.LH = 4096 + curval ; 
  563.       p = q ; 
  564.     } 
  565.     else if ( curval != 0 ) 
  566.     {
  567.       r = mem [ curval ] .hh .v.RH ; 
  568.       while ( r != 0 ) {
  569.       
  570.     {
  571.       {
  572.         q = avail ; 
  573.         if ( q == 0 ) 
  574.         q = getavail () ; 
  575.         else {
  576.         
  577.           avail = mem [ q ] .hh .v.RH ; 
  578.           mem [ q ] .hh .v.RH = 0 ; 
  579.     ;
  580. #ifdef STAT
  581.           incr ( dynused ) ; 
  582. #endif /* STAT */
  583.         } 
  584.       } 
  585.       mem [ p ] .hh .v.RH = q ; 
  586.       mem [ q ] .hh .v.LH = mem [ r ] .hh .v.LH ; 
  587.       p = q ; 
  588.     } 
  589.     r = mem [ r ] .hh .v.RH ; 
  590.       } 
  591.     } 
  592.     Result = p ; 
  593.   } 
  594.   else {
  595.       
  596.     oldsetting = selector ; 
  597.     selector = 21 ; 
  598.     switch ( curvallevel ) 
  599.     {case 0 : 
  600.       printint ( curval ) ; 
  601.       break ; 
  602.     case 1 : 
  603.       {
  604.     printscaled ( curval ) ; 
  605.     print ( 262 ) ; 
  606.       } 
  607.       break ; 
  608.     case 2 : 
  609.       {
  610.     printspec ( curval , 262 ) ; 
  611.     deleteglueref ( curval ) ; 
  612.       } 
  613.       break ; 
  614.     case 3 : 
  615.       {
  616.     printspec ( curval , 205 ) ; 
  617.     deleteglueref ( curval ) ; 
  618.       } 
  619.       break ; 
  620.     } 
  621.     selector = oldsetting ; 
  622.     Result = strtoks () ; 
  623.   } 
  624.   return(Result) ; 
  625. } 
  626. insthetoks () {
  627.     insthetoks_regmem 
  628.   mem [ memtop - 12 ] .hh .v.RH = thetoks () ; 
  629.   begintokenlist ( mem [ memtop - 3 ] .hh .v.RH , 4 ) ; 
  630. } 
  631. convtoks () {
  632.     convtoks_regmem 
  633.   schar oldsetting  ; 
  634.   schar c  ; 
  635.   smallnumber savescannerstatus  ; 
  636.   c = curchr ; 
  637.   switch ( c ) 
  638.   {case 0 : 
  639.   case 1 : 
  640.     scanint () ; 
  641.     break ; 
  642.   case 2 : 
  643.   case 3 : 
  644.     {
  645.       savescannerstatus = scannerstatus ; 
  646.       scannerstatus = 0 ; 
  647.       gettoken () ; 
  648.       scannerstatus = savescannerstatus ; 
  649.     } 
  650.     break ; 
  651.   case 4 : 
  652.     scanfontident () ; 
  653.     break ; 
  654.   case 5 : 
  655.     if ( jobname == 0 ) 
  656.     openlogfile () ; 
  657.     break ; 
  658.   } 
  659.   oldsetting = selector ; 
  660.   selector = 21 ; 
  661.   switch ( c ) 
  662.   {case 0 : 
  663.     printint ( curval ) ; 
  664.     break ; 
  665.   case 1 : 
  666.     printromanint ( curval ) ; 
  667.     break ; 
  668.   case 2 : 
  669.     if ( curcs != 0 ) 
  670.     sprintcs ( curcs ) ; 
  671.     else printchar ( curchr ) ; 
  672.     break ; 
  673.   case 3 : 
  674.     printmeaning () ; 
  675.     break ; 
  676.   case 4 : 
  677.     {
  678.       print ( fontname [ curval ] ) ; 
  679.       if ( fontsize [ curval ] != fontdsize [ curval ] ) 
  680.       {
  681.     print ( 598 ) ; 
  682.     printscaled ( fontsize [ curval ] ) ; 
  683.     print ( 262 ) ; 
  684.       } 
  685.     } 
  686.     break ; 
  687.   case 5 : 
  688.     print ( jobname ) ; 
  689.     break ; 
  690.   } 
  691.   selector = oldsetting ; 
  692.   mem [ memtop - 12 ] .hh .v.RH = strtoks () ; 
  693.   begintokenlist ( mem [ memtop - 3 ] .hh .v.RH , 4 ) ; 
  694. } 
  695. halfword zscantoks ( macrodef , xpand ) 
  696. boolean macrodef , xpand ; 
  697. {/* 40 30 31 32 */ register halfword Result; scantoks_regmem 
  698.   halfword t  ; 
  699.   halfword s  ; 
  700.   halfword p  ; 
  701.   halfword q  ; 
  702.   halfword unbalance  ; 
  703.   halfword hashbrace  ; 
  704.   if ( macrodef ) 
  705.   scannerstatus = 2 ; 
  706.   else scannerstatus = 5 ; 
  707.   warningindex = curcs ; 
  708.   defref = getavail () ; 
  709.   mem [ defref ] .hh .v.LH = 0 ; 
  710.   p = defref ; 
  711.   hashbrace = 0 ; 
  712.   t = 3120 ; 
  713.   if ( macrodef ) 
  714.   {
  715.     while ( true ) {
  716.     
  717.       gettoken () ; 
  718.       if ( curtok < 768 ) 
  719.       goto lab31 ; 
  720.       if ( curcmd == 6 ) 
  721.       {
  722.     s = 3328 + curchr ; 
  723.     gettoken () ; 
  724.     if ( curcmd == 1 ) 
  725.     {
  726.       hashbrace = curtok ; 
  727.       {
  728.         q = getavail () ; 
  729.         mem [ p ] .hh .v.RH = q ; 
  730.         mem [ q ] .hh .v.LH = curtok ; 
  731.         p = q ; 
  732.       } 
  733.       {
  734.         q = getavail () ; 
  735.         mem [ p ] .hh .v.RH = q ; 
  736.         mem [ q ] .hh .v.LH = 3584 ; 
  737.         p = q ; 
  738.       } 
  739.       goto lab30 ; 
  740.     } 
  741.     if ( t == 3129 ) 
  742.     {
  743.       {
  744.         if ( interaction == 3 ) 
  745.         wakeupterminal () ; 
  746.         printnl ( 133 ) ; 
  747.         print ( 601 ) ; 
  748.       } 
  749.       {
  750.         helpptr = 1 ; 
  751.         helpline [ 0 ] = 602 ; 
  752.       } 
  753.       error () ; 
  754.     } 
  755.     else {
  756.         
  757.       incr ( t ) ; 
  758.       if ( curtok != t ) 
  759.       {
  760.         {
  761.           if ( interaction == 3 ) 
  762.           wakeupterminal () ; 
  763.           printnl ( 133 ) ; 
  764.           print ( 603 ) ; 
  765.         } 
  766.         {
  767.           helpptr = 2 ; 
  768.           helpline [ 1 ] = 604 ; 
  769.           helpline [ 0 ] = 605 ; 
  770.         } 
  771.         backerror () ; 
  772.       } 
  773.       curtok = s ; 
  774.     } 
  775.       } 
  776.       {
  777.     q = getavail () ; 
  778.     mem [ p ] .hh .v.RH = q ; 
  779.     mem [ q ] .hh .v.LH = curtok ; 
  780.     p = q ; 
  781.       } 
  782.     } 
  783.     lab31: {
  784.     
  785.       q = getavail () ; 
  786.       mem [ p ] .hh .v.RH = q ; 
  787.       mem [ q ] .hh .v.LH = 3584 ; 
  788.       p = q ; 
  789.     } 
  790.     if ( curcmd == 2 ) 
  791.     {
  792.       {
  793.     if ( interaction == 3 ) 
  794.     wakeupterminal () ; 
  795.     printnl ( 133 ) ; 
  796.     print ( 515 ) ; 
  797.       } 
  798.       incr ( alignstate ) ; 
  799.       {
  800.     helpptr = 2 ; 
  801.     helpline [ 1 ] = 599 ; 
  802.     helpline [ 0 ] = 600 ; 
  803.       } 
  804.       error () ; 
  805.       goto lab40 ; 
  806.     } 
  807.     lab30: ; 
  808.   } 
  809.   else scanleftbrace () ; 
  810.   unbalance = 1 ; 
  811.   while ( true ) {
  812.       
  813.     if ( xpand ) 
  814.     {
  815.       while ( true ) {
  816.       
  817.     getnext () ; 
  818.     if ( curcmd <= 99 ) 
  819.     goto lab32 ; 
  820.     if ( curcmd != 108 ) 
  821.     expand () ; 
  822.     else {
  823.         
  824.       q = thetoks () ; 
  825.       if ( mem [ memtop - 3 ] .hh .v.RH != 0 ) 
  826.       {
  827.         mem [ p ] .hh .v.RH = mem [ memtop - 3 ] .hh .v.RH ; 
  828.         p = q ; 
  829.       } 
  830.     } 
  831.       } 
  832.       lab32: xtoken () ; 
  833.     } 
  834.     else gettoken () ; 
  835.     if ( curtok < 768 ) 
  836.     if ( curcmd < 2 ) 
  837.     incr ( unbalance ) ; 
  838.     else {
  839.     
  840.       decr ( unbalance ) ; 
  841.       if ( unbalance == 0 ) 
  842.       goto lab40 ; 
  843.     } 
  844.     else if ( curcmd == 6 ) 
  845.     if ( macrodef ) 
  846.     {
  847.       s = curtok ; 
  848.       if ( xpand ) 
  849.       getxtoken () ; 
  850.       else gettoken () ; 
  851.       if ( curcmd != 6 ) 
  852.       if ( ( curtok <= 3120 ) || ( curtok > t ) ) 
  853.       {
  854.     {
  855.       if ( interaction == 3 ) 
  856.       wakeupterminal () ; 
  857.       printnl ( 133 ) ; 
  858.       print ( 606 ) ; 
  859.     } 
  860.     sprintcs ( warningindex ) ; 
  861.     {
  862.       helpptr = 3 ; 
  863.       helpline [ 2 ] = 607 ; 
  864.       helpline [ 1 ] = 608 ; 
  865.       helpline [ 0 ] = 609 ; 
  866.     } 
  867.     backerror () ; 
  868.     curtok = s ; 
  869.       } 
  870.       else curtok = 1232 + curchr ; 
  871.     } 
  872.     {
  873.       q = getavail () ; 
  874.       mem [ p ] .hh .v.RH = q ; 
  875.       mem [ q ] .hh .v.LH = curtok ; 
  876.       p = q ; 
  877.     } 
  878.   } 
  879.   lab40: scannerstatus = 0 ; 
  880.   if ( hashbrace != 0 ) 
  881.   {
  882.     q = getavail () ; 
  883.     mem [ p ] .hh .v.RH = q ; 
  884.     mem [ q ] .hh .v.LH = hashbrace ; 
  885.     p = q ; 
  886.   } 
  887.   Result = p ; 
  888.   return(Result) ; 
  889. } 
  890. zreadtoks ( n , r ) 
  891. integer n ; 
  892. halfword r ; 
  893. {/* 30 */ readtoks_regmem 
  894.   halfword p  ; 
  895.   halfword q  ; 
  896.   integer s  ; 
  897.   smallnumber m  ; 
  898.   scannerstatus = 2 ; 
  899.   warningindex = r ; 
  900.   defref = getavail () ; 
  901.   mem [ defref ] .hh .v.LH = 0 ; 
  902.   p = defref ; 
  903.   {
  904.     q = getavail () ; 
  905.     mem [ p ] .hh .v.RH = q ; 
  906.     mem [ q ] .hh .v.LH = 3584 ; 
  907.     p = q ; 
  908.   } 
  909.   if ( ( n < 0 ) || ( n > 15 ) ) 
  910.   m = 16 ; 
  911.   else m = n ; 
  912.   s = alignstate ; 
  913.   alignstate = 1000000L ; 
  914.   do {
  915.       beginfilereading () ; 
  916.     curinput .namefield = m + 1 ; 
  917.     if ( readopen [ m ] == 2 ) 
  918.     if ( interaction > 1 ) 
  919.     if ( n < 0 ) 
  920.     {
  921.       wakeupterminal () ; 
  922.       print ( 206 ) ; 
  923.       terminput () ; 
  924.     } 
  925.     else {
  926.     
  927.       wakeupterminal () ; 
  928.       println () ; 
  929.       sprintcs ( r ) ; 
  930.       {
  931.     wakeupterminal () ; 
  932.     print ( 61 ) ; 
  933.     terminput () ; 
  934.       } 
  935.       n = -1 ; 
  936.     } 
  937.     else fatalerror ( 610 ) ; 
  938.     else if ( readopen [ m ] == 1 ) 
  939.     if ( inputln ( readfile [ m ] , false ) ) 
  940.     readopen [ m ] = 0 ; 
  941.     else {
  942.     
  943.       aclose ( readfile [ m ] ) ; 
  944.       readopen [ m ] = 2 ; 
  945.     } 
  946.     else {
  947.     
  948.       if ( ! inputln ( readfile [ m ] , true ) ) 
  949.       {
  950.     aclose ( readfile [ m ] ) ; 
  951.     readopen [ m ] = 2 ; 
  952.     if ( alignstate != 1000000L ) 
  953.     {
  954.       runaway () ; 
  955.       {
  956.         if ( interaction == 3 ) 
  957.         wakeupterminal () ; 
  958.         printnl ( 133 ) ; 
  959.         print ( 611 ) ; 
  960.       } 
  961.       printesc ( 392 ) ; 
  962.       {
  963.         helpptr = 1 ; 
  964.         helpline [ 0 ] = 612 ; 
  965.       } 
  966.       alignstate = 1000000L ; 
  967.       error () ; 
  968.     } 
  969.       } 
  970.     } 
  971.     curinput .limitfield = last ; 
  972.     if ( ( eqtb [ 5315 ] .cint < 0 ) || ( eqtb [ 5315 ] .cint > 127 ) ) 
  973.     decr ( curinput .limitfield ) ; 
  974.     else buffer [ curinput .limitfield ] = eqtb [ 5315 ] .cint ; 
  975.     first = curinput .limitfield + 1 ; 
  976.     curinput .locfield = curinput .startfield ; 
  977.     curinput .statefield = 33 ; 
  978.     while ( true ) {
  979.     
  980.       gettoken () ; 
  981.       if ( curtok == 0 ) 
  982.       goto lab30 ; 
  983.       {
  984.     q = getavail () ; 
  985.     mem [ p ] .hh .v.RH = q ; 
  986.     mem [ q ] .hh .v.LH = curtok ; 
  987.     p = q ; 
  988.       } 
  989.     } 
  990.     lab30: endfilereading () ; 
  991.   } while ( ! ( alignstate == 1000000L ) ) ; 
  992.   curval = defref ; 
  993.   scannerstatus = 0 ; 
  994.   alignstate = s ; 
  995. } 
  996. passtext () {
  997.     /* 30 */ passtext_regmem 
  998.   integer l  ; 
  999.   smallnumber savescannerstatus  ; 
  1000.   savescannerstatus = scannerstatus ; 
  1001.   scannerstatus = 1 ; 
  1002.   l = 0 ; 
  1003.   skipline = line ; 
  1004.   while ( true ) {
  1005.       
  1006.     getnext () ; 
  1007.     if ( curcmd == 105 ) 
  1008.     {
  1009.       if ( l == 0 ) 
  1010.       goto lab30 ; 
  1011.       if ( curchr == 2 ) 
  1012.       decr ( l ) ; 
  1013.     } 
  1014.     else if ( curcmd == 104 ) 
  1015.     incr ( l ) ; 
  1016.   } 
  1017.   lab30: scannerstatus = savescannerstatus ; 
  1018. } 
  1019. zchangeiflimit ( l , p ) 
  1020. smallnumber l ; 
  1021. halfword p ; 
  1022. {/* 10 */ changeiflimit_regmem 
  1023.   halfword q  ; 
  1024.   if ( p == condptr ) 
  1025.   iflimit = l ; 
  1026.   else {
  1027.       
  1028.     q = condptr ; 
  1029.     while ( true ) {
  1030.     
  1031.       if ( q == 0 ) 
  1032.       confusion ( 613 ) ; 
  1033.       if ( mem [ q ] .hh .v.RH == p ) 
  1034.       {
  1035.     mem [ q ] .hh.b0 = l ; 
  1036.     return ; 
  1037.       } 
  1038.       q = mem [ q ] .hh .v.RH ; 
  1039.     } 
  1040.   } 
  1041. } 
  1042. conditional () {
  1043.     /* 10 50 */ conditional_regmem 
  1044.   boolean b  ; 
  1045.   schar r  ; 
  1046.   integer m, n  ; 
  1047.   halfword p, q  ; 
  1048.   smallnumber savescannerstatus  ; 
  1049.   halfword savecondptr  ; 
  1050.   smallnumber thisif  ; 
  1051.   {
  1052.     p = getnode ( 2 ) ; 
  1053.     mem [ p ] .hh .v.RH = condptr ; 
  1054.     mem [ p ] .hh.b0 = iflimit ; 
  1055.     mem [ p ] .hh.b1 = curif ; 
  1056.     mem [ p + 1 ] .cint = ifline ; 
  1057.     condptr = p ; 
  1058.     curif = curchr ; 
  1059.     iflimit = 1 ; 
  1060.     ifline = line ; 
  1061.   } 
  1062.   savecondptr = condptr ; 
  1063.   thisif = curchr ; 
  1064.   switch ( thisif ) 
  1065.   {case 0 : 
  1066.   case 1 : 
  1067.     {
  1068.       {
  1069.     getxtoken () ; 
  1070.     if ( curcmd == 0 ) 
  1071.     if ( curchr == 257 ) 
  1072.     {
  1073.       curcmd = 13 ; 
  1074.       curchr = curtok - 4097 ; 
  1075.     } 
  1076.       } 
  1077.       if ( ( curcmd > 13 ) || ( curchr > 127 ) ) 
  1078.       {
  1079.     m = 0 ; 
  1080.     n = 256 ; 
  1081.       } 
  1082.       else {
  1083.       
  1084.     m = curcmd ; 
  1085.     n = curchr ; 
  1086.       } 
  1087.       {
  1088.     getxtoken () ; 
  1089.     if ( curcmd == 0 ) 
  1090.     if ( curchr == 257 ) 
  1091.     {
  1092.       curcmd = 13 ; 
  1093.       curchr = curtok - 4097 ; 
  1094.     } 
  1095.       } 
  1096.       if ( ( curcmd > 13 ) || ( curchr > 127 ) ) 
  1097.       {
  1098.     curcmd = 0 ; 
  1099.     curchr = 256 ; 
  1100.       } 
  1101.       if ( thisif == 0 ) 
  1102.       b = ( n == curchr ) ; 
  1103.       else b = ( m == curcmd ) ; 
  1104.     } 
  1105.     break ; 
  1106.   case 2 : 
  1107.   case 3 : 
  1108.     {
  1109.       if ( thisif == 2 ) 
  1110.       scanint () ; 
  1111.       else scandimen ( false , false , false ) ; 
  1112.       n = curval ; 
  1113.       do {
  1114.       getxtoken () ; 
  1115.       } while ( ! ( curcmd != 10 ) ) ; 
  1116.       if ( ( curtok >= 3132 ) && ( curtok <= 3134 ) ) 
  1117.       r = curtok - 3072 ; 
  1118.       else {
  1119.       
  1120.     {
  1121.       if ( interaction == 3 ) 
  1122.       wakeupterminal () ; 
  1123.       printnl ( 133 ) ; 
  1124.       print ( 637 ) ; 
  1125.     } 
  1126.     printcmdchr ( 104 , thisif ) ; 
  1127.     {
  1128.       helpptr = 1 ; 
  1129.       helpline [ 0 ] = 638 ; 
  1130.     } 
  1131.     backerror () ; 
  1132.     r = 61 ; 
  1133.       } 
  1134.       if ( thisif == 2 ) 
  1135.       scanint () ; 
  1136.       else scandimen ( false , false , false ) ; 
  1137.       switch ( r ) 
  1138.       {case 60 : 
  1139.     b = ( n < curval ) ; 
  1140.     break ; 
  1141.       case 61 : 
  1142.     b = ( n == curval ) ; 
  1143.     break ; 
  1144.       case 62 : 
  1145.     b = ( n > curval ) ; 
  1146.     break ; 
  1147.       } 
  1148.     } 
  1149.     break ; 
  1150.   case 4 : 
  1151.     {
  1152.       scanint () ; 
  1153.       b = odd ( curval ) ; 
  1154.     } 
  1155.     break ; 
  1156.   case 5 : 
  1157.     b = ( abs ( curlist .modefield ) == 1 ) ; 
  1158.     break ; 
  1159.   case 6 : 
  1160.     b = ( abs ( curlist .modefield ) == 101 ) ; 
  1161.     break ; 
  1162.   case 7 : 
  1163.     b = ( abs ( curlist .modefield ) == 201 ) ; 
  1164.     break ; 
  1165.   case 8 : 
  1166.     b = ( curlist .modefield < 0 ) ; 
  1167.     break ; 
  1168.   case 9 : 
  1169.   case 10 : 
  1170.   case 11 : 
  1171.     {
  1172.       scaneightbitint () ; 
  1173.       p = eqtb [ 4322 + curval ] .hh .v.RH ; 
  1174.       if ( thisif == 9 ) 
  1175.       b = ( p == 0 ) ; 
  1176.       else if ( p == 0 ) 
  1177.       b = false ; 
  1178.       else if ( thisif == 10 ) 
  1179.       b = ( mem [ p ] .hh.b0 == 0 ) ; 
  1180.       else b = ( mem [ p ] .hh.b0 == 1 ) ; 
  1181.     } 
  1182.     break ; 
  1183.   case 12 : 
  1184.     {
  1185.       savescannerstatus = scannerstatus ; 
  1186.       scannerstatus = 0 ; 
  1187.       getnext () ; 
  1188.       n = curcs ; 
  1189.       p = curcmd ; 
  1190.       q = curchr ; 
  1191.       getnext () ; 
  1192.       if ( curcmd != p ) 
  1193.       b = false ; 
  1194.       else if ( curcmd < 110 ) 
  1195.       b = ( curchr == q ) ; 
  1196.       else {
  1197.       
  1198.     p = mem [ curchr ] .hh .v.RH ; 
  1199.     q = mem [ eqtb [ n ] .hh .v.RH ] .hh .v.RH ; 
  1200.     while ( ( p != 0 ) && ( q != 0 ) ) if ( mem [ p ] .hh .v.LH != mem [ q 
  1201.     ] .hh .v.LH ) 
  1202.     p = 0 ; 
  1203.     else {
  1204.         
  1205.       p = mem [ p ] .hh .v.RH ; 
  1206.       q = mem [ q ] .hh .v.RH ; 
  1207.     } 
  1208.     b = ( ( p == 0 ) && ( q == 0 ) ) ; 
  1209.       } 
  1210.       scannerstatus = savescannerstatus ; 
  1211.     } 
  1212.     break ; 
  1213.   case 13 : 
  1214.     {
  1215.       scanfourbitint () ; 
  1216.       b = ( readopen [ curval ] == 2 ) ; 
  1217.     } 
  1218.     break ; 
  1219.   case 14 : 
  1220.     b = true ; 
  1221.     break ; 
  1222.   case 15 : 
  1223.     b = false ; 
  1224.     break ; 
  1225.   case 16 : 
  1226.     {
  1227.       scanint () ; 
  1228.       n = curval ; 
  1229.       if ( eqtb [ 5303 ] .cint > 1 ) 
  1230.       {
  1231.     begindiagnostic () ; 
  1232.     print ( 639 ) ; 
  1233.     printint ( n ) ; 
  1234.     printchar ( 125 ) ; 
  1235.     enddiagnostic ( false ) ; 
  1236.       } 
  1237.       while ( n != 0 ) {
  1238.       
  1239.     passtext () ; 
  1240.     if ( condptr == savecondptr ) 
  1241.     if ( curchr == 4 ) 
  1242.     decr ( n ) ; 
  1243.     else goto lab50 ; 
  1244.     else if ( curchr == 2 ) 
  1245.     {
  1246.       p = condptr ; 
  1247.       ifline = mem [ p + 1 ] .cint ; 
  1248.       curif = mem [ p ] .hh.b1 ; 
  1249.       iflimit = mem [ p ] .hh.b0 ; 
  1250.       condptr = mem [ p ] .hh .v.RH ; 
  1251.       freenode ( p , 2 ) ; 
  1252.     } 
  1253.       } 
  1254.       changeiflimit ( 4 , savecondptr ) ; 
  1255.       return ; 
  1256.     } 
  1257.     break ; 
  1258.   } 
  1259.   if ( eqtb [ 5303 ] .cint > 1 ) 
  1260.   {
  1261.     begindiagnostic () ; 
  1262.     if ( b ) 
  1263.     print ( 635 ) ; 
  1264.     else print ( 636 ) ; 
  1265.     enddiagnostic ( false ) ; 
  1266.   } 
  1267.   if ( b ) 
  1268.   {
  1269.     changeiflimit ( 3 , savecondptr ) ; 
  1270.     return ; 
  1271.   } 
  1272.   while ( true ) {
  1273.       
  1274.     passtext () ; 
  1275.     if ( condptr == savecondptr ) 
  1276.     {
  1277.       if ( curchr != 4 ) 
  1278.       goto lab50 ; 
  1279.       {
  1280.     if ( interaction == 3 ) 
  1281.     wakeupterminal () ; 
  1282.     printnl ( 133 ) ; 
  1283.     print ( 633 ) ; 
  1284.       } 
  1285.       printesc ( 631 ) ; 
  1286.       {
  1287.     helpptr = 1 ; 
  1288.     helpline [ 0 ] = 634 ; 
  1289.       } 
  1290.       error () ; 
  1291.     } 
  1292.     else if ( curchr == 2 ) 
  1293.     {
  1294.       p = condptr ; 
  1295.       ifline = mem [ p + 1 ] .cint ; 
  1296.       curif = mem [ p ] .hh.b1 ; 
  1297.       iflimit = mem [ p ] .hh.b0 ; 
  1298.       condptr = mem [ p ] .hh .v.RH ; 
  1299.       freenode ( p , 2 ) ; 
  1300.     } 
  1301.   } 
  1302.   lab50: if ( curchr == 2 ) 
  1303.   {
  1304.     p = condptr ; 
  1305.     ifline = mem [ p + 1 ] .cint ; 
  1306.     curif = mem [ p ] .hh.b1 ; 
  1307.     iflimit = mem [ p ] .hh.b0 ; 
  1308.     condptr = mem [ p ] .hh .v.RH ; 
  1309.     freenode ( p , 2 ) ; 
  1310.   } 
  1311.   else iflimit = 2 ; 
  1312. } 
  1313. beginname () {
  1314.     beginname_regmem 
  1315.   areadelimiter = 0 ; 
  1316.   extdelimiter = 0 ; 
  1317. } 
  1318. boolean zmorename ( c ) 
  1319. ASCIIcode c ; 
  1320. {register boolean Result; morename_regmem 
  1321.   if ( c == 32 ) 
  1322.   Result = false ; 
  1323.   else {
  1324.       
  1325.     if ( ( c == 47 ) ) 
  1326.     {
  1327.       areadelimiter = poolptr ; 
  1328.       extdelimiter = 0 ; 
  1329.     } 
  1330.     else if ( ( c == 46 ) && ( extdelimiter == 0 ) ) 
  1331.     extdelimiter = poolptr ; 
  1332.     {
  1333.       if ( poolptr + 1 > poolsize ) 
  1334.       overflow ( 128 , poolsize - initpoolptr ) ; 
  1335.     } 
  1336.     {
  1337.       strpool [ poolptr ] = c ; 
  1338.       incr ( poolptr ) ; 
  1339.     } 
  1340.     Result = true ; 
  1341.   } 
  1342.   return(Result) ; 
  1343. } 
  1344. endname () {
  1345.     endname_regmem 
  1346.   if ( strptr + 3 > maxstrings ) 
  1347.   overflow ( 129 , maxstrings - initstrptr ) ; 
  1348.   if ( areadelimiter == 0 ) 
  1349.   curarea = 206 ; 
  1350.   else {
  1351.       
  1352.     curarea = strptr ; 
  1353.     incr ( strptr ) ; 
  1354.     strstart [ strptr ] = areadelimiter + 1 ; 
  1355.   } 
  1356.   if ( extdelimiter == 0 ) 
  1357.   {
  1358.     curext = 206 ; 
  1359.     curname = makestring () ; 
  1360.   } 
  1361.   else {
  1362.       
  1363.     curname = strptr ; 
  1364.     incr ( strptr ) ; 
  1365.     strstart [ strptr ] = extdelimiter ; 
  1366.     curext = makestring () ; 
  1367.   } 
  1368. } 
  1369. zpackfilename ( n , a , e ) 
  1370. strnumber n , a , e ; 
  1371. {packfilename_regmem 
  1372.   integer k  ; 
  1373.   ASCIIcode c  ; 
  1374.   poolpointer j  ; 
  1375.   k = 0 ; 
  1376.   {register integer for_end; j = strstart [ a ] ; for_end = strstart [ a + 1 
  1377.   ] - 1 ; if ( j <= for_end) do 
  1378.     {
  1379.       c = strpool [ j ] ; 
  1380.       incr ( k ) ; 
  1381.       if ( k <= filenamesize ) 
  1382.       nameoffile [ k ] = xchr [ c ] ; 
  1383.     } 
  1384.   while ( j++ < for_end ) ; } 
  1385.   {register integer for_end; j = strstart [ n ] ; for_end = strstart [ n + 1 
  1386.   ] - 1 ; if ( j <= for_end) do 
  1387.     {
  1388.       c = strpool [ j ] ; 
  1389.       incr ( k ) ; 
  1390.       if ( k <= filenamesize ) 
  1391.       nameoffile [ k ] = xchr [ c ] ; 
  1392.     } 
  1393.   while ( j++ < for_end ) ; } 
  1394.   {register integer for_end; j = strstart [ e ] ; for_end = strstart [ e + 1 
  1395.   ] - 1 ; if ( j <= for_end) do 
  1396.     {
  1397.       c = strpool [ j ] ; 
  1398.       incr ( k ) ; 
  1399.       if ( k <= filenamesize ) 
  1400.       nameoffile [ k ] = xchr [ c ] ; 
  1401.     } 
  1402.   while ( j++ < for_end ) ; } 
  1403.   if ( k <= filenamesize ) 
  1404.   namelength = k ; 
  1405.   else namelength = filenamesize ; 
  1406.   {register integer for_end; k = namelength + 1 ; for_end = filenamesize 
  1407.   ; if ( k <= for_end) do 
  1408.     nameoffile [ k ] = ' ' ; 
  1409.   while ( k++ < for_end ) ; } 
  1410. } 
  1411. zpackbufferedname ( n , a , b ) 
  1412. smallnumber n ; 
  1413. integer a , b ; 
  1414. {packbufferedname_regmem 
  1415.   integer k  ; 
  1416.   ASCIIcode c  ; 
  1417.   integer j  ; 
  1418.   if ( n + b - a + 5 > filenamesize ) 
  1419.   b = a + filenamesize - n - 5 ; 
  1420.   k = 0 ; 
  1421.   {register integer for_end; j = 1 ; for_end = n ; if ( j <= for_end) do 
  1422.     {
  1423.       c = xord [ TEXformatdefault [ j ] ] ; 
  1424.       incr ( k ) ; 
  1425.       if ( k <= filenamesize ) 
  1426.       nameoffile [ k ] = xchr [ c ] ; 
  1427.     } 
  1428.   while ( j++ < for_end ) ; } 
  1429.   {register integer for_end; j = a ; for_end = b ; if ( j <= for_end) do 
  1430.     {
  1431.       c = buffer [ j ] ; 
  1432.       incr ( k ) ; 
  1433.       if ( k <= filenamesize ) 
  1434.       nameoffile [ k ] = xchr [ c ] ; 
  1435.     } 
  1436.   while ( j++ < for_end ) ; } 
  1437.   {register integer for_end; j = 6 ; for_end = 9 ; if ( j <= for_end) do 
  1438.     {
  1439.       c = xord [ TEXformatdefault [ j ] ] ; 
  1440.       incr ( k ) ; 
  1441.       if ( k <= filenamesize ) 
  1442.       nameoffile [ k ] = xchr [ c ] ; 
  1443.     } 
  1444.   while ( j++ < for_end ) ; } 
  1445.   if ( k <= filenamesize ) 
  1446.   namelength = k ; 
  1447.   else namelength = filenamesize ; 
  1448.   {register integer for_end; k = namelength + 1 ; for_end = filenamesize 
  1449.   ; if ( k <= for_end) do 
  1450.     nameoffile [ k ] = ' ' ; 
  1451.   while ( k++ < for_end ) ; } 
  1452. } 
  1453. strnumber makenamestring () {
  1454.     register strnumber Result; makenamestring_regmem 
  1455.   integer k, kstart  ; 
  1456.   k = 1 ; 
  1457.   while ( ( k < filenamesize ) && ( xord [ realnameoffile [ k ] ] != 32 ) ) 
  1458.   incr ( k ) ; 
  1459.   namelength = k - 1 ; 
  1460.   {
  1461.     if ( poolptr + namelength > poolsize ) 
  1462.     overflow ( 128 , poolsize - initpoolptr ) ; 
  1463.   } 
  1464.   if ( ( xord [ realnameoffile [ 1 ] ] == 46 ) && ( xord [ realnameoffile [ 2 
  1465.   ] ] == 47 ) ) 
  1466.   kstart = 3 ; 
  1467.   else kstart = 1 ; 
  1468.   {register integer for_end; k = kstart ; for_end = namelength ; if ( k <= 
  1469.   for_end) do 
  1470.     {
  1471.       strpool [ poolptr ] = xord [ realnameoffile [ k ] ] ; 
  1472.       incr ( poolptr ) ; 
  1473.     } 
  1474.   while ( k++ < for_end ) ; } 
  1475.   Result = makestring () ; 
  1476.   return(Result) ; 
  1477. } 
  1478. scanfilename () {
  1479.     /* 30 */ scanfilename_regmem 
  1480.   nameinprogress = true ; 
  1481.   beginname () ; 
  1482.   do {
  1483.       getxtoken () ; 
  1484.   } while ( ! ( curcmd != 10 ) ) ; 
  1485.   while ( true ) {
  1486.       
  1487.     if ( ( curcmd > 12 ) || ( curchr > 127 ) ) 
  1488.     {
  1489.       backinput () ; 
  1490.       goto lab30 ; 
  1491.     } 
  1492.     if ( ! morename ( curchr ) ) 
  1493.     goto lab30 ; 
  1494.     getxtoken () ; 
  1495.   } 
  1496.   lab30: endname () ; 
  1497.   nameinprogress = false ; 
  1498. } 
  1499. zpackjobname ( s ) 
  1500. strnumber s ; 
  1501. {packjobname_regmem 
  1502.   curarea = 206 ; 
  1503.   curext = s ; 
  1504.   curname = jobname ; 
  1505.   packfilename ( curname , curarea , curext ) ; 
  1506. } 
  1507. zpromptfilename ( s , e ) 
  1508. strnumber s , e ; 
  1509. {/* 30 */ promptfilename_regmem 
  1510.   integer k  ; 
  1511.   if ( interaction == 2 ) 
  1512.   wakeupterminal () ; 
  1513.   if ( s == 640 ) 
  1514.   {
  1515.     if ( interaction == 3 ) 
  1516.     wakeupterminal () ; 
  1517.     printnl ( 133 ) ; 
  1518.     print ( 641 ) ; 
  1519.   } 
  1520.   else {
  1521.       
  1522.     if ( interaction == 3 ) 
  1523.     wakeupterminal () ; 
  1524.     printnl ( 133 ) ; 
  1525.     print ( 642 ) ; 
  1526.   } 
  1527.   printfilename ( curname , curarea , curext ) ; 
  1528.   print ( 643 ) ; 
  1529.   if ( e == 644 ) 
  1530.   showcontext () ; 
  1531.   printnl ( 645 ) ; 
  1532.   print ( s ) ; 
  1533.   if ( interaction < 2 ) 
  1534.   fatalerror ( 646 ) ; 
  1535.   clearterminal () ; 
  1536.   {
  1537.     wakeupterminal () ; 
  1538.     print ( 426 ) ; 
  1539.     terminput () ; 
  1540.   } 
  1541.   {
  1542.     beginname () ; 
  1543.     k = first ; 
  1544.     while ( ( buffer [ k ] == 32 ) && ( k < last ) ) incr ( k ) ; 
  1545.     while ( true ) {
  1546.     
  1547.       if ( k == last ) 
  1548.       goto lab30 ; 
  1549.       if ( ! morename ( buffer [ k ] ) ) 
  1550.       goto lab30 ; 
  1551.       incr ( k ) ; 
  1552.     } 
  1553.     lab30: endname () ; 
  1554.   } 
  1555.   if ( curext == 206 ) 
  1556.   curext = e ; 
  1557.   packfilename ( curname , curarea , curext ) ; 
  1558. } 
  1559. openlogfile () {
  1560.     openlogfile_regmem 
  1561.   schar oldsetting  ; 
  1562.   integer k  ; 
  1563.   integer l  ; 
  1564.   ccharpointer months  ; 
  1565.   oldsetting = selector ; 
  1566.   if ( jobname == 0 ) 
  1567.   jobname = 649 ; 
  1568.   packjobname ( 650 ) ; 
  1569.   while ( ! aopenout ( logfile ) ) {
  1570.       
  1571.     if ( interaction < 2 ) 
  1572.     {
  1573.       {
  1574.     if ( interaction == 3 ) 
  1575.     wakeupterminal () ; 
  1576.     printnl ( 133 ) ; 
  1577.     print ( 642 ) ; 
  1578.       } 
  1579.       printfilename ( curname , curarea , curext ) ; 
  1580.       print ( 643 ) ; 
  1581.       jobname = 0 ; 
  1582.       history = 3 ; 
  1583.       jumpout () ; 
  1584.     } 
  1585.     promptfilename ( 652 , 650 ) ; 
  1586.   } 
  1587.   logname = amakenamestring ( logfile ) ; 
  1588.   selector = 18 ; 
  1589.   {
  1590.     (void) Fputs( logfile ,  "This is TeX, C Version 2.9" ) ; 
  1591.     print ( formatident ) ; 
  1592.     print ( 653 ) ; 
  1593.     printint ( eqtb [ 5288 ] .cint ) ; 
  1594.     printchar ( 32 ) ; 
  1595.     months = " JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC" ; 
  1596.     {register integer for_end; k = 3 * eqtb [ 5289 ] .cint - 2 ; for_end = 3 
  1597.     * eqtb [ 5289 ] .cint ; if ( k <= for_end) do 
  1598.       (void) putc( months [ k ] ,  logfile );
  1599.     while ( k++ < for_end ) ; } 
  1600.     printchar ( 32 ) ; 
  1601.     printint ( eqtb [ 5290 ] .cint ) ; 
  1602.     printchar ( 32 ) ; 
  1603.     printtwo ( eqtb [ 5287 ] .cint / 60 ) ; 
  1604.     printchar ( 58 ) ; 
  1605.     printtwo ( eqtb [ 5287 ] .cint % 60 ) ; 
  1606.   } 
  1607.   inputstack [ inputptr ] = curinput ; 
  1608.   printnl ( 651 ) ; 
  1609.   l = inputstack [ 0 ] .limitfield ; 
  1610.   if ( buffer [ l ] == eqtb [ 5315 ] .cint ) 
  1611.   decr ( l ) ; 
  1612.   {register integer for_end; k = 1 ; for_end = l ; if ( k <= for_end) do 
  1613.     print ( buffer [ k ] ) ; 
  1614.   while ( k++ < for_end ) ; } 
  1615.   println () ; 
  1616.   selector = oldsetting + 2 ; 
  1617. } 
  1618. startinput () {
  1619.     /* 30 */ startinput_regmem 
  1620.   scanfilename () ; 
  1621.   if ( curext == 206 ) 
  1622.   curext = 644 ; 
  1623.   packfilename ( curname , curarea , curext ) ; 
  1624.   while ( true ) {
  1625.       
  1626.     beginfilereading () ; 
  1627.     if ( aopenin ( inputfile [ curinput .indexfield ] , inputpathspec ) ) 
  1628.     goto lab30 ; 
  1629.     endfilereading () ; 
  1630.     promptfilename ( 640 , 644 ) ; 
  1631.   } 
  1632.   lab30: curinput .namefield = amakenamestring ( inputfile [ curinput 
  1633.   .indexfield ] ) ; 
  1634.   if ( jobname == 0 ) 
  1635.   {
  1636.     jobname = curname ; 
  1637.     openlogfile () ; 
  1638.   } 
  1639.   if ( termoffset + ( strstart [ curinput .namefield + 1 ] - strstart [ 
  1640.   curinput .namefield ] ) > maxprintline - 2 ) 
  1641.   println () ; 
  1642.   else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
  1643.   printchar ( 32 ) ; 
  1644.   printchar ( 40 ) ; 
  1645.   print ( curinput .namefield ) ; 
  1646.   termflush ( stdout ) ; 
  1647.   curinput .statefield = 33 ; 
  1648.   {
  1649.     if ( ! inputln ( inputfile [ curinput .indexfield ] , false ) ) 
  1650.     ; 
  1651.     firmuptheline () ; 
  1652.     if ( ( eqtb [ 5315 ] .cint < 0 ) || ( eqtb [ 5315 ] .cint > 127 ) ) 
  1653.     decr ( curinput .limitfield ) ; 
  1654.     else buffer [ curinput .limitfield ] = eqtb [ 5315 ] .cint ; 
  1655.     first = curinput .limitfield + 1 ; 
  1656.     curinput .locfield = curinput .startfield ; 
  1657.     line = 1 ; 
  1658.   } 
  1659. } 
  1660. internalfontnumber zreadfontinfo ( u , nom , aire , s ) 
  1661. halfword u ; 
  1662. strnumber nom , aire ; 
  1663. scaled s ; 
  1664. {/* 30 11 45 */ register internalfontnumber Result; 
  1665.   readfontinfo_regmem 
  1666.   integer k  ; 
  1667.   boolean fileopened  ; 
  1668.   halfword lf, lh, bc, ec, nw, nh, nd, ni, nl, nk, ne, np  ; 
  1669.   internalfontnumber f  ; 
  1670.   internalfontnumber g  ; 
  1671.   eightbits a, b, c, d  ; 
  1672.   fourquarters qw  ; 
  1673.   scaled sw  ; 
  1674.   scaled z  ; 
  1675.   integer alpha  ; 
  1676.   schar beta  ; 
  1677.   g = 0 ; 
  1678.   fileopened = false ; 
  1679.   packfilename ( nom , aire , 664 ) ; 
  1680.   if ( ! bopenin ( tfmfile ) ) 
  1681.   goto lab11 ; 
  1682.   fileopened = true ; 
  1683.   {
  1684.     {
  1685.       lf = tfmtemp ; 
  1686.       if ( lf > 127 ) 
  1687.       goto lab11 ; 
  1688.       tfmtemp = getc ( tfmfile ) ; 
  1689.       lf = lf * 256 + tfmtemp ; 
  1690.     } 
  1691.     tfmtemp = getc ( tfmfile ) ; 
  1692.     {
  1693.       lh = tfmtemp ; 
  1694.       if ( lh > 127 ) 
  1695.       goto lab11 ; 
  1696.       tfmtemp = getc ( tfmfile ) ; 
  1697.       lh = lh * 256 + tfmtemp ; 
  1698.     } 
  1699.     tfmtemp = getc ( tfmfile ) ; 
  1700.     {
  1701.       bc = tfmtemp ; 
  1702.       if ( bc > 127 ) 
  1703.       goto lab11 ; 
  1704.       tfmtemp = getc ( tfmfile ) ; 
  1705.       bc = bc * 256 + tfmtemp ; 
  1706.     } 
  1707.     tfmtemp = getc ( tfmfile ) ; 
  1708.     {
  1709.       ec = tfmtemp ; 
  1710.       if ( ec > 127 ) 
  1711.       goto lab11 ; 
  1712.       tfmtemp = getc ( tfmfile ) ; 
  1713.       ec = ec * 256 + tfmtemp ; 
  1714.     } 
  1715.     if ( ( bc > ec + 1 ) || ( ec > 255 ) ) 
  1716.     goto lab11 ; 
  1717.     tfmtemp = getc ( tfmfile ) ; 
  1718.     {
  1719.       nw = tfmtemp ; 
  1720.       if ( nw > 127 ) 
  1721.       goto lab11 ; 
  1722.       tfmtemp = getc ( tfmfile ) ; 
  1723.       nw = nw * 256 + tfmtemp ; 
  1724.     } 
  1725.     tfmtemp = getc ( tfmfile ) ; 
  1726.     {
  1727.       nh = tfmtemp ; 
  1728.       if ( nh > 127 ) 
  1729.       goto lab11 ; 
  1730.       tfmtemp = getc ( tfmfile ) ; 
  1731.       nh = nh * 256 + tfmtemp ; 
  1732.     } 
  1733.     tfmtemp = getc ( tfmfile ) ; 
  1734.     {
  1735.       nd = tfmtemp ; 
  1736.       if ( nd > 127 ) 
  1737.       goto lab11 ; 
  1738.       tfmtemp = getc ( tfmfile ) ; 
  1739.       nd = nd * 256 + tfmtemp ; 
  1740.     } 
  1741.     tfmtemp = getc ( tfmfile ) ; 
  1742.     {
  1743.       ni = tfmtemp ; 
  1744.       if ( ni > 127 ) 
  1745.       goto lab11 ; 
  1746.       tfmtemp = getc ( tfmfile ) ; 
  1747.       ni = ni * 256 + tfmtemp ; 
  1748.     } 
  1749.     tfmtemp = getc ( tfmfile ) ; 
  1750.     {
  1751.       nl = tfmtemp ; 
  1752.       if ( nl > 127 ) 
  1753.       goto lab11 ; 
  1754.       tfmtemp = getc ( tfmfile ) ; 
  1755.       nl = nl * 256 + tfmtemp ; 
  1756.     } 
  1757.     tfmtemp = getc ( tfmfile ) ; 
  1758.     {
  1759.       nk = tfmtemp ; 
  1760.       if ( nk > 127 ) 
  1761.       goto lab11 ; 
  1762.       tfmtemp = getc ( tfmfile ) ; 
  1763.       nk = nk * 256 + tfmtemp ; 
  1764.     } 
  1765.     tfmtemp = getc ( tfmfile ) ; 
  1766.     {
  1767.       ne = tfmtemp ; 
  1768.       if ( ne > 127 ) 
  1769.       goto lab11 ; 
  1770.       tfmtemp = getc ( tfmfile ) ; 
  1771.       ne = ne * 256 + tfmtemp ; 
  1772.     } 
  1773.     tfmtemp = getc ( tfmfile ) ; 
  1774.     {
  1775.       np = tfmtemp ; 
  1776.       if ( np > 127 ) 
  1777.       goto lab11 ; 
  1778.       tfmtemp = getc ( tfmfile ) ; 
  1779.       np = np * 256 + tfmtemp ; 
  1780.     } 
  1781.     if ( lf != 6 + lh + ( ec - bc + 1 ) + nw + nh + nd + ni + nl + nk + ne + 
  1782.     np ) 
  1783.     goto lab11 ; 
  1784.   } 
  1785.   lf = lf - 6 - lh ; 
  1786.   if ( np < 7 ) 
  1787.   lf = lf + 7 - np ; 
  1788.   if ( ( fontptr == fontmax ) || ( fmemptr + lf > fontmemsize ) ) 
  1789.   {
  1790.     {
  1791.       if ( interaction == 3 ) 
  1792.       wakeupterminal () ; 
  1793.       printnl ( 133 ) ; 
  1794.       print ( 655 ) ; 
  1795.     } 
  1796.     sprintcs ( u ) ; 
  1797.     printchar ( 61 ) ; 
  1798.     printfilename ( nom , aire , 206 ) ; 
  1799.     if ( s >= 0 ) 
  1800.     {
  1801.       print ( 598 ) ; 
  1802.       printscaled ( s ) ; 
  1803.       print ( 262 ) ; 
  1804.     } 
  1805.     else if ( s != -1000 ) 
  1806.     {
  1807.       print ( 656 ) ; 
  1808.       printint ( - (integer) s ) ; 
  1809.     } 
  1810.     print ( 665 ) ; 
  1811.     {
  1812.       helpptr = 4 ; 
  1813.       helpline [ 3 ] = 666 ; 
  1814.       helpline [ 2 ] = 667 ; 
  1815.       helpline [ 1 ] = 668 ; 
  1816.       helpline [ 0 ] = 669 ; 
  1817.     } 
  1818.     error () ; 
  1819.     goto lab30 ; 
  1820.   } 
  1821.   f = fontptr + 1 ; 
  1822.   charbase [ f ] = fmemptr - bc ; 
  1823.   widthbase [ f ] = charbase [ f ] + ec + 1 ; 
  1824.   heightbase [ f ] = widthbase [ f ] + nw ; 
  1825.   depthbase [ f ] = heightbase [ f ] + nh ; 
  1826.   italicbase [ f ] = depthbase [ f ] + nd ; 
  1827.   ligkernbase [ f ] = italicbase [ f ] + ni ; 
  1828.   kernbase [ f ] = ligkernbase [ f ] + nl ; 
  1829.   extenbase [ f ] = kernbase [ f ] + nk ; 
  1830.   parambase [ f ] = extenbase [ f ] + ne ; 
  1831.   {
  1832.     if ( lh < 2 ) 
  1833.     goto lab11 ; 
  1834.     {
  1835.       tfmtemp = getc ( tfmfile ) ; 
  1836.       a = tfmtemp ; 
  1837.       qw .b0 = a ; 
  1838.       tfmtemp = getc ( tfmfile ) ; 
  1839.       b = tfmtemp ; 
  1840.       qw .b1 = b ; 
  1841.       tfmtemp = getc ( tfmfile ) ; 
  1842.       c = tfmtemp ; 
  1843.       qw .b2 = c ; 
  1844.       tfmtemp = getc ( tfmfile ) ; 
  1845.       d = tfmtemp ; 
  1846.       qw .b3 = d ; 
  1847.       fontcheck [ f ] = qw ; 
  1848.     } 
  1849.     tfmtemp = getc ( tfmfile ) ; 
  1850.     {
  1851.       z = tfmtemp ; 
  1852.       if ( z > 127 ) 
  1853.       goto lab11 ; 
  1854.       tfmtemp = getc ( tfmfile ) ; 
  1855.       z = z * 256 + tfmtemp ; 
  1856.     } 
  1857.     tfmtemp = getc ( tfmfile ) ; 
  1858.     z = z * 256 + tfmtemp ; 
  1859.     tfmtemp = getc ( tfmfile ) ; 
  1860.     z = ( z * 16 ) + ( tfmtemp / 16 ) ; 
  1861.     if ( z < 65536L ) 
  1862.     goto lab11 ; 
  1863.     while ( lh > 2 ) {
  1864.     
  1865.       tfmtemp = getc ( tfmfile ) ; 
  1866.       tfmtemp = getc ( tfmfile ) ; 
  1867.       tfmtemp = getc ( tfmfile ) ; 
  1868.       tfmtemp = getc ( tfmfile ) ; 
  1869.       decr ( lh ) ; 
  1870.     } 
  1871.     fontdsize [ f ] = z ; 
  1872.     if ( s != -1000 ) 
  1873.     if ( s >= 0 ) 
  1874.     z = s ; 
  1875.     else z = xnoverd ( z , - (integer) s , 1000 ) ; 
  1876.     fontsize [ f ] = z ; 
  1877.   } 
  1878.   {register integer for_end; k = fmemptr ; for_end = widthbase [ f ] - 1 
  1879.   ; if ( k <= for_end) do 
  1880.     {
  1881.       {
  1882.     tfmtemp = getc ( tfmfile ) ; 
  1883.     a = tfmtemp ; 
  1884.     qw .b0 = a ; 
  1885.     tfmtemp = getc ( tfmfile ) ; 
  1886.     b = tfmtemp ; 
  1887.     qw .b1 = b ; 
  1888.     tfmtemp = getc ( tfmfile ) ; 
  1889.     c = tfmtemp ; 
  1890.     qw .b2 = c ; 
  1891.     tfmtemp = getc ( tfmfile ) ; 
  1892.     d = tfmtemp ; 
  1893.     qw .b3 = d ; 
  1894.     fontinfo [ k ] .qqqq = qw ; 
  1895.       } 
  1896.       if ( ( a >= nw ) || ( b / 16 >= nh ) || ( b % 16 >= nd ) || ( c / 4 >= 
  1897.       ni ) ) 
  1898.       goto lab11 ; 
  1899.       switch ( c % 4 ) 
  1900.       {case 1 : 
  1901.     if ( d >= nl ) 
  1902.     goto lab11 ; 
  1903.     break ; 
  1904.       case 3 : 
  1905.     if ( d >= ne ) 
  1906.     goto lab11 ; 
  1907.     break ; 
  1908.       case 2 : 
  1909.     {
  1910.       {
  1911.         if ( ( d < bc ) || ( d > ec ) ) 
  1912.         goto lab11 ; 
  1913.       } 
  1914.       while ( d < k + bc - fmemptr ) {
  1915.           
  1916.         qw = fontinfo [ charbase [ f ] + d ] .qqqq ; 
  1917.         if ( ( ( qw .b2 ) % 4 ) != 2 ) 
  1918.         goto lab45 ; 
  1919.         d = qw .b3 ; 
  1920.       } 
  1921.       if ( d == k + bc - fmemptr ) 
  1922.       goto lab11 ; 
  1923.       lab45: ; 
  1924.     } 
  1925.     break ; 
  1926.     default: 
  1927.     ; 
  1928.     break ; 
  1929.       } 
  1930.     } 
  1931.   while ( k++ < for_end ) ; } 
  1932.   {
  1933.     {
  1934.       alpha = 16 ; 
  1935.       while ( z >= 8388608L ) {
  1936.       
  1937.     z = z / 2 ; 
  1938.     alpha = alpha + alpha ; 
  1939.       } 
  1940.       beta = 256 / alpha ; 
  1941.       alpha = alpha * z ; 
  1942.     } 
  1943.     {register integer for_end; k = widthbase [ f ] ; for_end = ligkernbase [ 
  1944.     f ] - 1 ; if ( k <= for_end) do 
  1945.       {
  1946.     tfmtemp = getc ( tfmfile ) ; 
  1947.     a = tfmtemp ; 
  1948.     tfmtemp = getc ( tfmfile ) ; 
  1949.     b = tfmtemp ; 
  1950.     tfmtemp = getc ( tfmfile ) ; 
  1951.     c = tfmtemp ; 
  1952.     tfmtemp = getc ( tfmfile ) ; 
  1953.     d = tfmtemp ; 
  1954.     sw = ( ( ( ( ( d * z ) / 256 ) + ( c * z ) ) / 256 ) + ( b * z ) ) / 
  1955.     beta ; 
  1956.     if ( a == 0 ) 
  1957.     fontinfo [ k ] .cint = sw ; 
  1958.     else if ( a == 255 ) 
  1959.     fontinfo [ k ] .cint = sw - alpha ; 
  1960.     else goto lab11 ; 
  1961.       } 
  1962.     while ( k++ < for_end ) ; } 
  1963.     if ( fontinfo [ widthbase [ f ] ] .cint != 0 ) 
  1964.     goto lab11 ; 
  1965.     if ( fontinfo [ heightbase [ f ] ] .cint != 0 ) 
  1966.     goto lab11 ; 
  1967.     if ( fontinfo [ depthbase [ f ] ] .cint != 0 ) 
  1968.     goto lab11 ; 
  1969.     if ( fontinfo [ italicbase [ f ] ] .cint != 0 ) 
  1970.     goto lab11 ; 
  1971.   } 
  1972.   {
  1973.     {register integer for_end; k = ligkernbase [ f ] ; for_end = kernbase [ f 
  1974.     ] - 1 ; if ( k <= for_end) do 
  1975.       {
  1976.     {
  1977.       tfmtemp = getc ( tfmfile ) ; 
  1978.       a = tfmtemp ; 
  1979.       qw .b0 = a ; 
  1980.       tfmtemp = getc ( tfmfile ) ; 
  1981.       b = tfmtemp ; 
  1982.       qw .b1 = b ; 
  1983.       tfmtemp = getc ( tfmfile ) ; 
  1984.       c = tfmtemp ; 
  1985.       qw .b2 = c ; 
  1986.       tfmtemp = getc ( tfmfile ) ; 
  1987.       d = tfmtemp ; 
  1988.       qw .b3 = d ; 
  1989.       fontinfo [ k ] .qqqq = qw ; 
  1990.     } 
  1991.     {
  1992.       if ( ( b < bc ) || ( b > ec ) ) 
  1993.       goto lab11 ; 
  1994.     } 
  1995.     if ( c < 128 ) 
  1996.     {
  1997.       if ( ( d < bc ) || ( d > ec ) ) 
  1998.       goto lab11 ; 
  1999.     } 
  2000.     else if ( d >= nk ) 
  2001.     goto lab11 ; 
  2002.       } 
  2003.     while ( k++ < for_end ) ; } 
  2004.     if ( ( nl > 0 ) && ( a < 128 ) ) 
  2005.     goto lab11 ; 
  2006.     {register integer for_end; k = kernbase [ f ] ; for_end = extenbase [ f ] 
  2007.     - 1 ; if ( k <= for_end) do 
  2008.       {
  2009.     tfmtemp = getc ( tfmfile ) ; 
  2010.     a = tfmtemp ; 
  2011.     tfmtemp = getc ( tfmfile ) ; 
  2012.     b = tfmtemp ; 
  2013.     tfmtemp = getc ( tfmfile ) ; 
  2014.     c = tfmtemp ; 
  2015.     tfmtemp = getc ( tfmfile ) ; 
  2016.     d = tfmtemp ; 
  2017.     sw = ( ( ( ( ( d * z ) / 256 ) + ( c * z ) ) / 256 ) + ( b * z ) ) / 
  2018.     beta ; 
  2019.     if ( a == 0 ) 
  2020.     fontinfo [ k ] .cint = sw ; 
  2021.     else if ( a == 255 ) 
  2022.     fontinfo [ k ] .cint = sw - alpha ; 
  2023.     else goto lab11 ; 
  2024.       } 
  2025.     while ( k++ < for_end ) ; } 
  2026.   } 
  2027.   {register integer for_end; k = extenbase [ f ] ; for_end = parambase [ f ] 
  2028.   - 1 ; if ( k <= for_end) do 
  2029.     {
  2030.       {
  2031.     tfmtemp = getc ( tfmfile ) ; 
  2032.     a = tfmtemp ; 
  2033.     qw .b0 = a ; 
  2034.     tfmtemp = getc ( tfmfile ) ; 
  2035.     b = tfmtemp ; 
  2036.     qw .b1 = b ; 
  2037.     tfmtemp = getc ( tfmfile ) ; 
  2038.     c = tfmtemp ; 
  2039.     qw .b2 = c ; 
  2040.     tfmtemp = getc ( tfmfile ) ; 
  2041.     d = tfmtemp ; 
  2042.     qw .b3 = d ; 
  2043.     fontinfo [ k ] .qqqq = qw ; 
  2044.       } 
  2045.       if ( a != 0 ) 
  2046.       {
  2047.     if ( ( a < bc ) || ( a > ec ) ) 
  2048.     goto lab11 ; 
  2049.       } 
  2050.       if ( b != 0 ) 
  2051.       {
  2052.     if ( ( b < bc ) || ( b > ec ) ) 
  2053.     goto lab11 ; 
  2054.       } 
  2055.       if ( c != 0 ) 
  2056.       {
  2057.     if ( ( c < bc ) || ( c > ec ) ) 
  2058.     goto lab11 ; 
  2059.       } 
  2060.       {
  2061.     if ( ( d < bc ) || ( d > ec ) ) 
  2062.     goto lab11 ; 
  2063.       } 
  2064.     } 
  2065.   while ( k++ < for_end ) ; } 
  2066.   {
  2067.     {register integer for_end; k = 1 ; for_end = np ; if ( k <= for_end) do 
  2068.       if ( k == 1 ) 
  2069.       {
  2070.     tfmtemp = getc ( tfmfile ) ; 
  2071.     sw = tfmtemp ; 
  2072.     if ( sw > 127 ) 
  2073.     sw = sw - 256 ; 
  2074.     tfmtemp = getc ( tfmfile ) ; 
  2075.     sw = sw * 256 + tfmtemp ; 
  2076.     tfmtemp = getc ( tfmfile ) ; 
  2077.     sw = sw * 256 + tfmtemp ; 
  2078.     tfmtemp = getc ( tfmfile ) ; 
  2079.     fontinfo [ parambase [ f ] ] .cint = ( sw * 16 ) + ( tfmtemp / 16 ) ; 
  2080.       } 
  2081.       else {
  2082.       
  2083.     tfmtemp = getc ( tfmfile ) ; 
  2084.     a = tfmtemp ; 
  2085.     tfmtemp = getc ( tfmfile ) ; 
  2086.     b = tfmtemp ; 
  2087.     tfmtemp = getc ( tfmfile ) ; 
  2088.     c = tfmtemp ; 
  2089.     tfmtemp = getc ( tfmfile ) ; 
  2090.     d = tfmtemp ; 
  2091.     sw = ( ( ( ( ( d * z ) / 256 ) + ( c * z ) ) / 256 ) + ( b * z ) ) / 
  2092.     beta ; 
  2093.     if ( a == 0 ) 
  2094.     fontinfo [ parambase [ f ] + k - 1 ] .cint = sw ; 
  2095.     else if ( a == 255 ) 
  2096.     fontinfo [ parambase [ f ] + k - 1 ] .cint = sw - alpha ; 
  2097.     else goto lab11 ; 
  2098.       } 
  2099.     while ( k++ < for_end ) ; } 
  2100.     if ( eof ( tfmfile ) ) 
  2101.     goto lab11 ; 
  2102.     {register integer for_end; k = np + 1 ; for_end = 7 ; if ( k <= for_end) 
  2103.     do 
  2104.       fontinfo [ parambase [ f ] + k - 1 ] .cint = 0 ; 
  2105.     while ( k++ < for_end ) ; } 
  2106.   } 
  2107.   if ( np >= 7 ) 
  2108.   fontparams [ f ] = np ; 
  2109.   else fontparams [ f ] = 7 ; 
  2110.   hyphenchar [ f ] = eqtb [ 5313 ] .cint ; 
  2111.   skewchar [ f ] = eqtb [ 5314 ] .cint ; 
  2112.   fontname [ f ] = nom ; 
  2113.   fontarea [ f ] = aire ; 
  2114.   fontbc [ f ] = bc ; 
  2115.   fontec [ f ] = ec ; 
  2116.   fontglue [ f ] = 0 ; 
  2117.   charbase [ f ] = charbase [ f ] ; 
  2118.   widthbase [ f ] = widthbase [ f ] ; 
  2119.   ligkernbase [ f ] = ligkernbase [ f ] ; 
  2120.   kernbase [ f ] = kernbase [ f ] ; 
  2121.   extenbase [ f ] = extenbase [ f ] ; 
  2122.   decr ( parambase [ f ] ) ; 
  2123.   fmemptr = fmemptr + lf ; 
  2124.   fontptr = f ; 
  2125.   g = f ; 
  2126.   goto lab30 ; 
  2127.   lab11: {
  2128.       
  2129.     if ( interaction == 3 ) 
  2130.     wakeupterminal () ; 
  2131.     printnl ( 133 ) ; 
  2132.     print ( 655 ) ; 
  2133.   } 
  2134.   sprintcs ( u ) ; 
  2135.   printchar ( 61 ) ; 
  2136.   printfilename ( nom , aire , 206 ) ; 
  2137.   if ( s >= 0 ) 
  2138.   {
  2139.     print ( 598 ) ; 
  2140.     printscaled ( s ) ; 
  2141.     print ( 262 ) ; 
  2142.   } 
  2143.   else if ( s != -1000 ) 
  2144.   {
  2145.     print ( 656 ) ; 
  2146.     printint ( - (integer) s ) ; 
  2147.   } 
  2148.   if ( fileopened ) 
  2149.   print ( 657 ) ; 
  2150.   else print ( 658 ) ; 
  2151.   {
  2152.     helpptr = 5 ; 
  2153.     helpline [ 4 ] = 659 ; 
  2154.     helpline [ 3 ] = 660 ; 
  2155.     helpline [ 2 ] = 661 ; 
  2156.     helpline [ 1 ] = 662 ; 
  2157.     helpline [ 0 ] = 663 ; 
  2158.   } 
  2159.   error () ; 
  2160.   lab30: if ( fileopened ) 
  2161.   bclose ( tfmfile ) ; 
  2162.   Result = g ; 
  2163.   return(Result) ; 
  2164. } 
  2165.